The present invention relates, in general, to databases and methods for accessing such databases with query objects, and, in particular, to apparatus and methods for interactively examining database information, including database schema information, for the construction of query objects.
Databases represent an important data processing area in many applications. They are often used to store large amounts of information and then efficiently retrieve selected portions of the information. Many present day systems use a client/server database approach in which application programs running in clients access a central database management system (DBMS) located in a database server. In order to efficiently access the information in the database, the clients form queries which request information with selected characteristics. The queries are transmitted to the DBMS server which retrieves the desired information which meets the characteristics specified in the query. The results (commonly called a xe2x80x9cresult setxe2x80x9d) are returned to the client.
Presently, such database environments are predominantly based on a xe2x80x9ctwo-tieredxe2x80x9d model consisting of a top tier containing one or more applications which generate queries that access the DBMS server in a bottom tier. The two-tiered model suffers from several drawbacks. First, the queries must be formulated in a specific query language, which is accepted by the DBMS server. While standard query languages exist, such as the Structured Query Language (SQL), specific DBMS query languages are often non-standard as a result of proprietary extensions made to the basic SQL query language. As a result, application programs written to generate queries in a particular query language are often not portable between different DBMS servers.
In addition, in order to generate the queries in the first place, each application developer, and, in some cases, the ultimate user, must understand the mechanics of the database, including the relationship of the files and tables therein and any relationships in the data required by the database organization. These relationships are commonly referred to as xe2x80x9cbusiness logicxe2x80x9d since the relationships are typically based on shared business processes, practices and policies. Therefore, many parties must learn the business logic in order to generate meaningful queries.
Further, commonly-performed routines are typically replicated in each application program even if the application programs operate within the same business environment because each application functions autonomously from other applications. This replication results in poor code re-use and maintenance problems if the replicated routines must be changed.
Consequently, there is a trend towards using a three-tiered model for database environments. Generally, the top tier in such a model consists of clients containing the application programs and the user interfaces, the middle tier consists of code that embodies the business logic and the bottom tier consists of the DBMS servers which contain the data. In this model, the applications are implemented as xe2x80x9cthinxe2x80x9d clients, all of which interface with the business logic by means, of a common interface which does not involve knowledge of the business logic. The commonly-performed routines are all consolidated into the middle tier as part of the business logic. Since the business logic is shareable between the clients, code replication is avoided. The Common Object Request Broker Architecture (CORBA) presents one object-oriented approach to forming a three-tiered database environment, such as described in R. Orfali et al., xe2x80x9cThe Essential Client/Server Survival Guide,xe2x80x9d pp. 375-458, John Wiley and Sons, Inc. (2d ed. 1996), the disclosure of which is incorporated herein by reference.
Several prior art methods of implementing the three-tiered model exist, however, most existing DBMS access mechanisms arid tools, including fourth generation languages (4GLs) and application programming interfaces (APIs), have been designed for the two-tiered model and are ill-suited for use in the three-tiered model. Consequently, several prior art designs including xe2x80x9cdatabasexe2x80x9d objects and xe2x80x9cactive dataxe2x80x9d objects have their own strengths and drawbacks. One promising prior art approach to constructing a middle tier containing business logic uses xe2x80x9cquery objects.xe2x80x9d Each query object is a server object that:
(1) translates client method invocations into equivalent queries in a query language which is understood by a database;
(2) issues those queries to the database; and
(3) returns the results as strongly-typed data values.
The query object effectively encapsulates the DBMS specific query language so that the application programs do not have to know or use the DBMS query language. Query objects also encapsulate the database organization or xe2x80x9cschemaxe2x80x9d, so that query object clients are isolated from database changes (although the query object itself may have to be changed if the underlying database must be changed.) Query objects also present their clients with a DBMS independent API, for example, CORBA defines an Interface Definition Language (IDL) interface. They do not require that the data be mapped into objects as is the case with active data objects so that significant performance advantages can be obtained and concurrency issues avoided.
Each query object provides as part of its interface one or more parameterized methods and calls on each method are translated by the query object into one or more standard queries such as SELECT, UPDATE, INSERT and DELETE, or into initiation of one or more stored procedures in the database. In order to use the query object, a client first establishes a connection to the query object via some mechanism, such as the CORBA naming service. One of the query object""s methods is then invoked and the query object then executes the query.
However, in order to operate properly, the query object must be constructed to generate the correct DBMS queries in response to client requests. Otherwise, the query object may operate as designed, but produce results which are not intended. Constructing a query object to generate the correct queries requires a knowledge of SQL, an understanding of the underlying database schema, the possible handling of intermediate results generated by the query and interpretation of the results. In addition, a query object developer must consider other issues such as connection to the database using CORBA or similar arrangement, concurrency problems and translation required between the interface used by the query object and the API used by the database. Consequently, tools have been developed to automate the generation of query objects. Some tools can generate a query object from a query described in conventional SQL language which is entered, by a user.
However, even with such tools, it may be necessary to understand the schema of the underlying database in order to correctly construct the initial SQL query and map the SQL query into the query language used by the underlying database. Since the database schema is related to the business logic, it is therefore, necessary to understand the business logic at some level. At the very least, the query object developer must obtain the names of tables and stored procedures in the database and their descriptions, including column names and types for tables and input and output parameters for stored procedures. For a particular query, it is also necessary to obtain a description of the result set produced by the query, including numbers and types of result expressions as well as possible bounds on the result set.
Further, the underlying database may use vendor specific data types which do not directly match the standard data types used in SQL expressions. Consequently, it may be necessary to first translate the data types before the query can be used. While these translations are well-known, they can be time-consuming details which distract the user from other, more important work.
Therefore, there is a need to easily obtain and display the database schema and automate testing of the query object, especially objects created with automatic generation tools. There is a further need to test query objects with actual data.
The foregoing problems are solved in one illustrative embodiment of the invention in which a query object generator tool which generates interface definitions and code that implement a query object can also generate a database schema access query object that retrieves the database schema. Instead of retrieving data from the database, the database schema access query object retrieves xe2x80x9cmetadataxe2x80x9d concerning the database schema from the database. The metadata is then displayed as part of a graphic user interface which is used to construct the SQL query implemented by the query object.
The metadata retrieved by the database schema access object includes, but is not limited to, metadata which is defined for example, in the Java Database Connectivity (JDBC) 2.0 standard, including such data as the names of tables and stored procedures in the database and their descriptions, including column names and types for tables, input and output parameters for stored procedures and information about indexes, primary and foreign key relationships between tables.
In accordance with one embodiment of the invention, the database schema access object also verifies that an SQL query created by a user is valid by submitting the query to the database engine of the underlying database. This submission generates a result set and allows the database schema access object to display to the user a full description of the result set, including the types of resultant attributes as well as possible bounds on the cardinality of the result set.
In accordance with another embodiment of the invention the database schema access object contains methods which perform automatic mapping of xe2x80x9cstandardxe2x80x9d SQL data types to vendor-specific data types so that the internal representation of the query object and most of the query generator tool internal code is not dependent on the underlying DBMS.